\documentclass{report}

\usepackage[french]{babel}
\usepackage[utf8]{inputenc}
\usepackage{amsmath}
\usepackage{mathtools}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage{graphicx}
\usepackage{vmargin}
\usepackage{listings}
\usepackage{color}
\usepackage{url}
\usepackage[colorlinks=true]{hyperref}
\hypersetup{urlcolor=blue,linkcolor=black,citecolor=black,colorlinks=true}
\usepackage{float}
\usepackage{listingsutf8}
\usepackage{titlesec}

\urlstyle{sf}

\lstset{
	tabsize=4,
        basicstyle=\scriptsize,
        aboveskip={1.5\baselineskip},
        columns=fixed,
        showstringspaces=false,
        extendedchars=true,
        breaklines=true,
        prebreak = \raisebox{0ex}[0ex][0ex]{\ensuremath{\hookleftarrow}},
	frame=single,
        showtabs=false,
        showspaces=false,
        showstringspaces=false,
        identifierstyle=\ttfamily,
        keywordstyle=\color[rgb]{0,0,1},
        commentstyle=\color[rgb]{0.133,0.545,0.133},
        stringstyle=\color[rgb]{0.627,0.126,0.941},
	language=C,
	inputencoding=utf8/latin1
}

\titleformat{\chapter}[hang]{\bf\huge}{\thechapter}{2pc}{}

\begin{document}
     \begin{figure}[h]
                \begin{center}
                        \title	{Informatique 2\up{ème} année \\
	                        \textbf {\LARGE{Projet OS}} \\
				Rapport intermédiaire
				}

                        \author{Sylvain \bsc{Bilange}\\\and Alexis \bsc{Ferriere} \and Jérôme \bsc{Boé} \and Chen \bsc{Song} \and Rachid \bsc{Abid}}
                        \maketitle
                        \null
                        \null
                        \null
                        \null
                        \null
                        \null
                        \null
                        \null
                        \null
                        \null
                        \null
                        \null
                        \null
                       	\includegraphics[scale=0.2]{pictures/logo_enseirb.png}\\
                        ENSEIRB-MATMECA\\
                        1 Avenue du docteur Albert Schweitzer \\
                        33402 Talence\\
                \end{center}
        \end{figure}



	\setcounter{page}{0}

	\thispagestyle{empty}

	\clearpage

	\clearpage

	\chapter{Introduction}
        Le projet porte sur la gestion des threads au sein d'un système d'exploitation. Il est acquit qu'un très grand nombre de threads peuvent 
    avoir besoin de tourner sur une même machine. En raison des ressources physiques limitées, il est nécessaire d'imposer une gestion stricte de ces threads. C'est ce que doit assurer notre bibliothèque, qui devra avoir un comportement similaire à celui de $pthread.h$. Dans un premier temps, nous devons mettre en place un ordonnancement de type coopératif, c'est à dire sans préemption, et nous le testerons sur un programme d'exemple fourni.   
    
    \chapter{Structure de données}

        En mémoire, nous avons estimé d'un thread devait obligatoirement avoir un identifiant, une variable caractéristique 
	de son état (SLEEPING, READY...), une priorité (ce qui permet de faire passer un thread plutôt qu'un autre). 
	D'un point de vue plus technique, il faut aussi un pointeur vers un thread prêt à prendre la suite quand il aura fini de tourner, 
	ainsi qu'un contexte,  et un pointeur vers un -éventuel- autre thread dans la liste chaînée, puis la valeur de retour du thread.
	Nous avons donc représenté nos threads de la manière suivante :\\ 

        \begin{lstlisting}
	struct thread{
		pid_t id;
		ucontext_t uc;
		struct thread *next;
		struct thread *joiner;
		status st;
		unsigned char priority;
		void *retval;
	};
    \end{lstlisting}
	~\\
        Comme vous pouvez le constater, les threads qui seront en attente seront chaînés entre eux, ce qui apparaît être la solution la plus efficace sachant que l'on sera en permanence amenés à supprimer et ajouter des éléments. Nous avons donc implémenté un module de gestion des listes, relativement classique. En effet, on extrait en tête, et on ajoute un thread de manière triée en fonction de la priorité. En voici les fonctions :\\

\begin{lstlisting}
	struct queue_thread {
		thread_t first;
		thread_t last;
	};

	struct queue_thread* new_queue_thread ();
	thread_t get_first_thread (const struct queue_thread *q);
	thread_t extract_first_thread (struct queue_thread *q);
	void add_thread (struct queue_thread *q, thread_t t);
	void print_queue (struct queue_thread *qt);
\end{lstlisting}


        Il y aura a priori plusieurs listes, mais nous n'en avons pour l'instant qu'une seule, qui contient tous les threads en attente. 
        ~\\
        Un module de test a été implémenté, et le comportement semble correct, comme en témoigne la figure ~\ref{list} :     

        \begin{center}
            \begin{figure}[h]
               \includegraphics[scale=0.3]{pictures/test_list2.png}
               \caption{\label{list} tests du module list.h}
            \end{figure}    
        \end{center}

	\chapter{Comportement des threads}

        thread\_create :
        ~\\
		Cette fonction a pour rôle de créer un nouveau thread, en le plaçant par défaut dans la runqueue avec une priorité de 20 et un statut READY. 

        ~\\
        ~\\

        thread\_yield :
        ~\\
		La fonction thread\_yield signifie au thread courant qu'il passe la main au thread en tête de la liste des threads en attente. Il s'agit d'un simple remplacement.

        ~\\
        ~\\

        thread\_join :
        ~\\
        La fonction thread\_join permet au thread courant d'attendre la fin d'exécution d'un thread. Elle est aussi utilisé dans le cas où un thread nécessite la valeur de retour d'un autre thread.

        Pour que l'ordonnanceur puisse réveiller facilement le joineur d'un thread, on se limite au cas où il y a au plus un joineur pour chaque thread. Il est donc naturel d'avoir un champ "joiner" dans la structure de thread. Ce champ est affecté par le thread courant lorsque ce dernier appelle la fonction "thread\_join". Avant qu'un thread se termine, il doit réveiller son "joiner", et eventuellement lui passer la valeur de retour.

        ~\\
        ~\\

        thread\_exit :
        ~\\
        Cette fonction a pour but de tuer un thread et libérer les ressources. Mais avant de quitter, un thread doit réveiller son joiner s'il existe et passer la main au thread suivant qui est en état prêt à exécuter. Cette fonction doit être appelé par tous les threads à la fin de leur exécution. Pour ce faire, on génère un contexte particulier qui exécute la fonction "thread\_exit". Le champ uc\_link du contexte de chaque thread pointe vers ce contexte afin que ce dernier puisse s'exécuter automatiquement avant de tuer le thread.


    \chapter{Conclusion}
    
        Nous n'en sommes actuellement qu'au tout début du projet et il reste donc une bonne partie du travail à effectuer. 
        Il faudra donc être efficace sur le temps restant.
         
        Cependant, nous avons pu cerner les enjeux du projet puisque notre implémentation atteint le premier objectif 
        qui est d'éxécuter correctement l'exemple fourni, cela constitue une première satisfaction. 
        De plus, l'organisation au niveau du groupe a été et est toujours bonne, ce qui est bon signe pour la suite.  


\end{document}

